#pragma once

#include "Hash.h"
#include <type_traits>

template<typename... TypeN> class TTuple;

//两个元素的元组
template<typename Type0,typename Type1>
class TTuple <Type0,Type1>
{
public:

	bool operator==(const TTuple<Type0,Type1>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::GetHashCode(Second));
	}

	Type0  First;
	Type1  Second;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		>
	TTuple<Type0,Type1> MakeTuple(RawType0&& InFirst,RawType1&& InSecond)
	{
		return TTuple<Type0,Type1>{std::forward<RawType0>(InFirst),std::forward<RawType1>(InSecond)};
	}

	template<typename RawType0
		,typename RawType1
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		>
	TTuple<Type0,Type1>* NewTuple(RawType0&& InFirst,RawType1&& InSecond)
	{
		return new TTuple<Type0,Type1>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)};
	}
}

//三个元素的元组
template<typename Type0,typename Type1,typename Type2>
class TTuple<Type0,Type1,Type2>
{
public:
	bool operator==(const TTuple<Type0,Type1,Type2>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::GetHashCode(Third)));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		>
	TTuple<Type0,Type1,Type2> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird)
	{
		return TTuple<Type0,Type1,Type2>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)};
	}

	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		>

	TTuple<Type0,Type1,Type2>* NewTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird)
	{
		return new TTuple<Type0,Type1,Type2>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)};
	}
}

//四个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3>
class TTuple<Type0,Type1,Type2,Type3>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::GetHashCode(Fourth))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		>
	TTuple<Type0,Type1,Type2,Type3> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth)
	{
		return TTuple<Type0,Type1,Type2,Type3>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)};
	}
}

//五个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4>
class TTuple<Type0,Type1,Type2,Type3,Type4>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3,Type4>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth
			&&Fifth == Other.Fifth;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::HashCombine(WH::GetHashCode(Fourth), WH::GetHashCode(Fifth)))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
	Type4  Fifth;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		>

	TTuple<Type0,Type1,Type2,Type3,Type4> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth)
	{
		return TTuple<Type0,Type1,Type2,Type3,Type4>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)};
	}

	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4>* NewTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth)
	{
		return new TTuple<Type0,Type1,Type2,Type3,Type4>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)};
	}
}

//六个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5>
class TTuple<Type0,Type1,Type2,Type3,Type4,Type5>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3,Type4,Type5>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth
			&&Fifth == Other.Fifth
			&&Sixth == Other.Sixth;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::HashCombine(WH::GetHashCode(Fourth), WH::HashCombine(WH::GetHashCode(Fifth), WH::GetHashCode(Sixth))))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
	Type4  Fifth;
	Type5  Sixth;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth)
	{
		return TTuple<Type0,Type1,Type2,Type3,Type4,Type5>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)};
	}

	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5>* NewTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth)
	{
		return new TTuple<Type0,Type1,Type2,Type3,Type4,Type5>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)};
	}
}

//七个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5,typename Type6>
class TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth
			&&Fifth == Other.Fifth
			&&Sixth == Other.Sixth
			&&Seventh == Other.Seventh;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::HashCombine(WH::GetHashCode(Fourth), WH::HashCombine(WH::GetHashCode(Fifth), WH::HashCombine(WH::GetHashCode(Sixth), WH::GetHashCode(Seventh)))))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
	Type4  Fifth;
	Type5  Sixth;
	Type6  Seventh;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename RawType6
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		,typename Type6=std::remove_cvref_t <RawType6>
		>

	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth,RawType6&& InSeventh)
	{
		return TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)
			,std::forward<RawType6>(InSeventh)};
	}

	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename RawType6
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		,typename Type6=std::remove_cvref_t <RawType6>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6>* NewTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth,RawType6&& InSeventh)
	{
		return new TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)
			,std::forward<RawType6>(InSeventh)};
	}
}

//八个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5,typename Type6,typename Type7>
class TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth
			&&Fifth == Other.Fifth
			&&Sixth == Other.Sixth
			&&Seventh == Other.Seventh
			&&Eighth == Other.Eighth;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::HashCombine(WH::GetHashCode(Fourth), WH::HashCombine(WH::GetHashCode(Fifth), WH::HashCombine(WH::GetHashCode(Sixth), WH::HashCombine(WH::GetHashCode(Seventh), WH::GetHashCode(Eighth))))))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
	Type4  Fifth;
	Type5  Sixth;
	Type6  Seventh;
	Type7  Eighth;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename RawType6
		,typename RawType7
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		,typename Type6=std::remove_cvref_t <RawType6>
		,typename Type7=std::remove_cvref_t <RawType7>
		>	
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth,RawType6&& InSeventh,RawType7&& InEighth)
	{
		return TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)
			,std::forward<RawType6>(InSeventh)
			,std::forward<RawType7>(InEighth)};
	}

	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename RawType6
		,typename RawType7
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		,typename Type6=std::remove_cvref_t <RawType6>
		,typename Type7=std::remove_cvref_t <RawType7>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7>* NewTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth,RawType6&& InSeventh,RawType7&& InEighth)
	{
		return new TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)
			,std::forward<RawType6>(InSeventh)
			,std::forward<RawType7>(InEighth)};
	}
}

//九个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5,typename Type6,typename Type7,typename Type8>
class TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth
			&&Fifth == Other.Fifth
			&&Sixth == Other.Sixth
			&&Seventh == Other.Seventh
			&&Eighth == Other.Eighth
			&&Ninth == Other.Ninth;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::HashCombine(WH::GetHashCode(Fourth), WH::HashCombine(WH::GetHashCode(Fifth), WH::HashCombine(WH::GetHashCode(Sixth), WH::HashCombine(WH::GetHashCode(Seventh), WH::HashCombine(WH::GetHashCode(Eighth), WH::GetHashCode(Ninth)))))))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
	Type4  Fifth;
	Type5  Sixth;
	Type6  Seventh;
	Type7  Eighth;
	Type8  Ninth;
};

namespace WH
{
	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename RawType6
		,typename RawType7
		,typename RawType8
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		,typename Type6=std::remove_cvref_t <RawType6>
		,typename Type7=std::remove_cvref_t <RawType7>
		,typename Type8=std::remove_cvref_t <RawType8>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8> MakeTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth,RawType6&& InSeventh,RawType7&& InEighth,RawType8&& InNinth)
	{
		return TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)
			,std::forward<RawType6>(InSeventh)
			,std::forward<RawType7>(InEighth)
			,std::forward<RawType8>(InNinth)};
	}

	template<typename RawType0
		,typename RawType1
		,typename RawType2
		,typename RawType3
		,typename RawType4
		,typename RawType5
		,typename RawType6
		,typename RawType7
		,typename RawType8
		,typename Type0=std::remove_cvref_t <RawType0>
		,typename Type1=std::remove_cvref_t <RawType1>
		,typename Type2=std::remove_cvref_t <RawType2>
		,typename Type3=std::remove_cvref_t <RawType3>
		,typename Type4=std::remove_cvref_t <RawType4>
		,typename Type5=std::remove_cvref_t <RawType5>
		,typename Type6=std::remove_cvref_t <RawType6>
		,typename Type7=std::remove_cvref_t <RawType7>
		,typename Type8=std::remove_cvref_t <RawType8>
		>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8>* NewTuple(RawType0&& InFirst,RawType1&& InSecond,RawType2&& InThird,RawType3&& InFourth,RawType4&& InFifth,RawType5&& InSixth,RawType6&& InSeventh,RawType7&& InEighth,RawType8&& InNinth)
	{
		return new TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8>{
			std::forward<RawType0>(InFirst)
			,std::forward<RawType1>(InSecond)
			,std::forward<RawType2>(InThird)
			,std::forward<RawType3>(InFourth)
			,std::forward<RawType4>(InFifth)
			,std::forward<RawType5>(InSixth)
			,std::forward<RawType6>(InSeventh)
			,std::forward<RawType7>(InEighth)
			,std::forward<RawType8>(InNinth)};
	}
}

//十个元素的元组
template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5,typename Type6,typename Type7,typename Type8,typename Type9>
class TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8,Type9>
{
public:

	bool operator==(const TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8,Type9>& Other)const
	{
		return First == Other.First
			&&Second == Other.Second
			&&Third == Other.Third
			&&Fourth == Other.Fourth
			&&Fifth == Other.Fifth
			&&Sixth == Other.Sixth
			&&Seventh == Other.Seventh
			&&Eighth == Other.Eighth
			&&Ninth == Other.Ninth
			&&Tenth == Other.Tenth;
	}

	uint64_t GetHashCode() const
	{
		return WH::HashCombine(WH::GetHashCode(First), WH::HashCombine(WH::GetHashCode(Second), WH::HashCombine(WH::GetHashCode(Third), WH::HashCombine(WH::GetHashCode(Fourth), WH::HashCombine(WH::GetHashCode(Fifth), WH::HashCombine(WH::GetHashCode(Sixth), WH::HashCombine(WH::GetHashCode(Seventh), WH::HashCombine(WH::GetHashCode(Eighth), WH::HashCombine(WH::GetHashCode(Ninth), WH::GetHashCode(Tenth))))))))));
	}

	Type0  First;
	Type1  Second;
	Type2  Third;
	Type3  Fourth;
	Type4  Fifth;
	Type5  Sixth;
	Type6  Seventh;
	Type7  Eighth;
	Type8  Ninth;
	Type9  Tenth;
};

namespace WH
{
	template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5,typename Type6,typename Type7,typename Type8,typename Type9>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8,Type9> MakeTuple(Type0&& InFirst,Type1&& InSecond,Type2&& InThird,Type3&& InFourth,Type4&& InFifth,Type5&& InSixth,Type6&& InSeventh,Type7&& InEighth,Type8&& InNinth,Type9&& InTenth)
	{
		return TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8,Type9>{
			std::forward<Type0>(InFirst)
			,std::forward<Type1>(InSecond)
			,std::forward<Type2>(InThird)
			,std::forward<Type3>(InFourth)
			,std::forward<Type4>(InFifth)
			,std::forward<Type5>(InSixth)
			,std::forward<Type6>(InSeventh)
			,std::forward<Type7>(InEighth)
			,std::forward<Type8>(InNinth)
			,std::forward<Type9>(InTenth)};
	}

	template<typename Type0,typename Type1,typename Type2,typename Type3,typename Type4,typename Type5,typename Type6,typename Type7,typename Type8,typename Type9>
	TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8,Type9>* NewTuple(const Type0& InFirst,const Type1& InSecond,const Type2& InThird,const Type3& InFourth,const Type4& InFifth,const Type5& InSixth,const Type6& InSeventh,const Type7& InEighth,const Type8& InNinth,const Type9& InTenth)
	{
		return new TTuple<Type0,Type1,Type2,Type3,Type4,Type5,Type6,Type7,Type8,Type9>{InFirst,InSecond,InThird,InFourth,InFifth,InSixth,InSeventh,InEighth,InNinth,InTenth};
	}

}